home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et-2_2.lha / et2.2 / src / Text.C < prev    next >
C/C++ Source or Header  |  1990-12-04  |  10KB  |  593 lines
  1. //$Text,TextIter$
  2. #include "Text.h"
  3. #include "Error.h"
  4. #include "RegularExp.h"
  5. #include "Mark.h"
  6. #include "Port.h"
  7. #include "OrdColl.h"
  8.  
  9. //---- LineDesc --------------------------------------------------------
  10.  
  11. LineDesc::LineDesc(int b, int h)
  12. {
  13.     lnAscent = b;
  14.     lnHeight = h;
  15. } 
  16.  
  17. void LineDesc::Reset()
  18. {
  19.     lnAscent = 0;
  20.     lnHeight = 0;
  21. }
  22.  
  23. void LineDesc::Max(FontPtr f)
  24. { 
  25.     lnHeight =  max(lnHeight-lnAscent,f->Spacing()-f->Ascender()) +
  26.         max(f->Ascender(),lnAscent);
  27.     lnAscent =  max(f->Ascender(),lnAscent);
  28. }
  29.  
  30. void LineDesc::Max(LineDesc ld)
  31. { 
  32.     lnHeight =  max(lnHeight-lnAscent,ld.lnHeight - ld.lnAscent) +
  33.         max(ld.lnAscent,lnAscent);
  34.     lnAscent =  max(ld.lnAscent,lnAscent);
  35. }
  36.  
  37. void LineDesc::Max(int ascent, int height)
  38. {
  39.     lnHeight =  max(lnHeight-lnAscent,height-ascent) +
  40.         max(ascent,lnAscent);
  41.     lnAscent =  max(ascent,lnAscent);     
  42. }    
  43.  
  44. ostream& LineDesc::DisplayOn (ostream&s)
  45. {
  46.     return s << "Ascent=" << lnAscent << "/Height=" << lnHeight;
  47. }
  48.  
  49. //---- Text ------------------------------------------------------------
  50.  
  51. AbstractMetaImpl(Text, (TP(marks), TP(observers), 0));
  52.  
  53. Text::Text()
  54. { 
  55.     tabWidth = cTabw;
  56.     marks = 0;
  57.     observers= 0;
  58. }
  59.  
  60. Text::~Text()
  61. {   
  62.     if (marks) {
  63.     marks->FreeAll();
  64.     delete marks;
  65.     }   
  66.     if (observers) 
  67.     CleanupObservers(observers);
  68. }
  69.  
  70. void Text::InitNew()
  71. {
  72.     marks = 0;
  73.     tabWidth = cTabw;
  74. }
  75.  
  76. void Text::CalcIws (int width, int from, int *to, int *addSpace, 
  77.                         int *longBlanks, int *ntab)
  78. {
  79.     int nBlanks;
  80.     int ch;
  81.  
  82.     nBlanks = *addSpace = *longBlanks = *ntab = 0;
  83.  
  84.     for ( ;*to-1 >= from && ((*this)[*to-1] == ' ' || (*this)[*to-1] == '\t'); 
  85.                                     (*to)--) 
  86.     ;
  87.  
  88.     AutoTextIter ti(this,from,*to);
  89.     int w = TextWidth(from,*to);
  90.     while ((ch = ti()) != cEOT) {
  91.     if (ch == '\t') {
  92.         (*ntab)++;
  93.         nBlanks = 0;
  94.     }
  95.     else if (ch == ' ')
  96.         nBlanks++;
  97.     }
  98.     if (nBlanks) {
  99.     *longBlanks = (width - w) % nBlanks;
  100.     *addSpace = (width - w) / nBlanks;
  101.     }
  102. }
  103.  
  104. void Text::Cut(int from,int to)
  105. {
  106.     if (marks)
  107.     marks->Cut(from,to - from);
  108. }
  109.  
  110. void Text::Paste(TextPtr t, int from, int to)
  111. {
  112.     if (marks) {
  113.     if (from != to)
  114.         marks->Cut(from,to - from);
  115.     marks->Paste(from,t->Size()); 
  116.     }
  117. }
  118.  
  119. void Text::Copy(Text *, int , int)
  120. {
  121.     AbstractMethod("Copy");
  122. }
  123.  
  124. void Text::CopyInStr(byte*, int, int, int)
  125. {
  126.     AbstractMethod("CopyInStr");
  127. }
  128.  
  129. void Text::ReplaceWithStr(byte*, int)
  130. {
  131.     AbstractMethod("ReplaceWithStr");
  132. }
  133.  
  134. void Text::SetFStringVL(char *, va_list)
  135. {
  136.     AbstractMethod("SetFStringVL");
  137. }
  138.  
  139. void Text::SetFString(char *va_(fmt), ...)
  140. {
  141.     va_list ap;
  142.     va_start(ap,va_(fmt));
  143.     SetFStringVL(va_(fmt), ap);
  144.     va_end(ap);    
  145. }
  146.  
  147. byte *Text::GetTextAt(int, int)
  148. {
  149.     AbstractMethod("GetTextAt");
  150.     return 0;
  151. }
  152.  
  153. int Text::Search(RegularExp *rex, int *nMatched, int start, int range, 
  154.                          bool forward)
  155. {
  156.     int pos;
  157.     char *s = AsString();
  158.     if (forward) 
  159.     pos= rex->SearchForward (s, nMatched, start, Size(), range, 0);
  160.     else
  161.     pos= rex->SearchBackward (s, nMatched, start, Size(), range, 0); 
  162.     delete s;
  163.     return pos;
  164. }
  165.  
  166. Text *Text::GetScratchText(int) 
  167. {
  168.     return (TextPtr)this->New();
  169. }
  170.  
  171. TextPtr Text::Save(int, int)
  172. {
  173.     AbstractMethod("Save");
  174.     return 0;
  175. }
  176.  
  177. void Text::Insert(byte, int from, int to)
  178. {
  179.     if (marks) {
  180.     if (from != to)
  181.         marks->Cut(from,to - from);
  182.     marks->Paste(from,1); 
  183.     }
  184. }
  185.  
  186. void Text::Append(byte c)
  187. {
  188.     Insert(c, Size(), Size());
  189. }
  190.  
  191. static byte dummyc;
  192.  
  193. byte& Text::operator[](int )
  194. {
  195.     AbstractMethod("operator[]");
  196.     return dummyc;
  197. }
  198.  
  199. void Text::Empty (int)                                         
  200. {
  201.     AbstractMethod("Empty");
  202. }
  203.  
  204. int Text::Size ()                                         
  205. {
  206.     AbstractMethod("Size");
  207.     return 0;
  208. }
  209.  
  210. void Text::GetWordBoundaries(int at, int *start, int *end)
  211. {
  212.     register int i;
  213.  
  214.     if (!CheckRange(Size(), at, at))
  215.     return;
  216.  
  217.     for (i = at-1; i >= 0 && Isinword((*this)[i]); i--)
  218.     ;
  219.     *start = i+1; 
  220.     for (i = at; i < Size() && Isinword((*this)[i]); i++)
  221.     ; 
  222.     *end = i;
  223. }
  224.  
  225. void Text::GetParagraphBoundaries(int at,int *start,int *end)
  226. {
  227.     register int i, ch;
  228.  
  229.     if (!CheckRange(Size(), at, at))
  230.     return;
  231.  
  232.     for (i = at-1; i >= 0; i--) {
  233.     ch= (*this)[i];
  234.     if (ch == '\n' || ch == '\r')
  235.         break;
  236.     }
  237.     *start = i+1; 
  238.     for (i = at; i < Size(); i++) {
  239.     ch= (*this)[i];
  240.     if (ch == '\n' || ch == '\r')
  241.         break; 
  242.     }
  243.     *end= min(Size(), i+1);
  244. }
  245.  
  246. int Text::Tabulate(int x)
  247. {
  248.     if (tabWidth > 0) {
  249.     int n = x / tabWidth;
  250.     return ((n+1) * tabWidth - x);
  251.     }
  252.     return 0;
  253. }
  254.  
  255. int Text::SetTabWidth(int t)
  256. {
  257.     int ot= tabWidth;
  258.     tabWidth= t;
  259.     return ot;
  260. }
  261.  
  262. TextIter *Text::MakeIterator(int,int)
  263. {
  264.     AbstractMethod("MakeIterator ");
  265.     return 0;    
  266. }
  267.  
  268. void Text::SetFont(FontPtr fp) 
  269. {
  270.     font= fp;
  271. }
  272.  
  273. FontPtr Text::GetFont(int)
  274. {
  275.     return font;
  276. }
  277.  
  278. void Text::SetInk(Ink *c) 
  279. {
  280.     ink= c;
  281. }
  282.  
  283. Ink *Text::GetInk(int)
  284. {
  285.     return ink;
  286. }
  287.  
  288. FontPtr Text::SetDrawingState(int at)
  289. {
  290.     FontPtr fp= GetFont();
  291.     GrSetFont(GetFont(at));
  292.     GrSetTextPattern(GetInk());
  293.     return fp;        
  294. }
  295.  
  296. void Text::ResetCurrentStyle()
  297. {
  298. }
  299.  
  300. int Text::TextWidth(int, int)
  301. {
  302.     AbstractMethod("TextWidth ");
  303.     return 0;
  304. }
  305.  
  306. void Text::DrawText(int, int, Rectangle)
  307. {
  308.     AbstractMethod("DrawText ");
  309. }
  310.  
  311. void Text::DrawTextJust (int from, int to, int w, Point start, Rectangle)
  312. {
  313.     register byte ch;
  314.     int ntab, longBlanks, addSpace, seenTabs;
  315.  
  316.     if (!CheckRange(Size(), from, to))
  317.     return;
  318.  
  319.     ntab= longBlanks= seenTabs = 0;
  320.  
  321.     CalcIws(w, from, &to, &addSpace, &longBlanks, &ntab);    
  322.  
  323.     FontPtr font= SetDrawingState(from);
  324.     GrTextMoveto(start);
  325.  
  326.     for (int i = from, nBlanks = 0; i < to; i++) {
  327.     switch (ch = (*this)[i]) {
  328.     case '\t':
  329.         GrTextAdvance(Tabulate(GrGetTextPos().x-start.x));
  330.         seenTabs++;
  331.         break;
  332.     case ' ':
  333.         GrTextAdvance(font->Width(' '));
  334.         if (seenTabs == ntab) {
  335.         GrTextAdvance(addSpace);
  336.         if (nBlanks < longBlanks)
  337.             GrTextAdvance(1);
  338.         nBlanks++;
  339.         }
  340.         break;
  341.     default:
  342.         GrDrawChar(ch);
  343.         break;
  344.     }
  345.     }
  346. }
  347.  
  348. void Text::JustifiedMap(int from, int to, int w, int stopAt, int posX, 
  349.                                int *charPos, int *x)
  350. {
  351.     register byte ch;
  352.     int ntab, longBlanks, addSpace, seenTabs, cx, wx;
  353.     FontPtr font = GetFont();
  354.     if (!CheckRange(Size(), from, to))
  355.     return;
  356.  
  357.     wx= cx= ntab= longBlanks= addSpace= seenTabs= 0;
  358.  
  359.     CalcIws(w, from, &to, &addSpace, &longBlanks, &ntab);    
  360.  
  361.     for (int i = from, nBlanks = 0; i < to && i < stopAt; i++) {
  362.     switch (ch = (*this)[i]) {
  363.     case '\t':
  364.         wx = Tabulate(cx);
  365.         seenTabs++;
  366.         break;
  367.     case ' ':
  368.         wx = font->Width(' ');
  369.         if (seenTabs == ntab) {
  370.         wx += addSpace;
  371.         if (nBlanks < longBlanks)
  372.             wx++; 
  373.         nBlanks++;
  374.         }
  375.         break;
  376.     default:
  377.         wx = font->Width(ch); 
  378.         break;
  379.     }
  380.     if (cx + (wx/2) > posX)
  381.         break;
  382.     cx += wx;
  383.     }
  384.     if (x)
  385.     *x = cx;
  386.     if (charPos)
  387.     *charPos = i;
  388. }
  389.  
  390. void Text::Map(int from, int to, int stopAt, int posX, int *charPos, int *x)
  391. {
  392.     int ch,cx,wx,i;
  393.  
  394.     cx= wx= 0;
  395.  
  396.     AutoTextIter ti(this,from,to);
  397.  
  398.     for (i= from; (ch = ti(&wx)) != cEOT && i < stopAt ; i++) {
  399.     if (ch == '\t') 
  400.         wx = Tabulate(cx);
  401.     if (cx + (wx/2) > posX) 
  402.         break;
  403.     cx += wx;
  404.     }    
  405.     if (charPos)
  406.     *charPos = i;
  407.     if (x)
  408.     *x = cx;
  409. }
  410.  
  411. char *Text::AsString()
  412. {
  413.     int s= Size();
  414.     char *buf= new char[s+1];
  415.     CopyInStr((byte*)buf, s+1, 0, s);
  416.     return buf;    
  417. }
  418.  
  419. int Text::AsInt()
  420. {
  421.     int val;
  422.     if (Size() == 0)
  423.     return 0;
  424.     char *p= AsString();
  425.     sscanf(p, "%d", &val);
  426.     delete p;
  427.     return val; 
  428. }
  429.  
  430. float Text::AsFloat()
  431. {
  432.     float val;
  433.     char *p = AsString();
  434.     sscanf(p,"%f",&val);
  435.     delete p;
  436.     return val; 
  437. }
  438.  
  439. ostream& Text::PrintOnAsPureText(ostream &s)
  440. {
  441.     AbstractMethod("PrintOnAsPureText");
  442.     return s;
  443. }
  444.  
  445. istream& Text::ReadFromAsPureText(istream &s, long)
  446. {
  447.     AbstractMethod("ReadFromAsPureText");
  448.     return s;
  449. }
  450.  
  451. bool Text::IsEmpty() 
  452. {
  453.     return Size() == 0;
  454. }
  455.  
  456. int Text::GrowBy(int desiredSize)
  457. {
  458.     int s= 0;
  459.  
  460.     if (Size() >= cMaxInt)
  461.     Error("GrowBy", "cannot expand text");
  462.     else 
  463.     s= range(2, cMaxInt - desiredSize, desiredSize);
  464.     return Size()+s;
  465. } 
  466.  
  467. void Text::AddMark(Mark *m)
  468. {
  469.     if (marks == 0)
  470.     marks= new MarkList;
  471.     marks->Add(m);
  472. }
  473.  
  474. Mark *Text::RemoveMark(Mark *m)
  475. {
  476.     if (marks == 0)
  477.     marks= new MarkList;
  478.     return (Mark*)marks->Remove(m);
  479. }
  480.  
  481. Iterator *Text::GetMarkIter()
  482. {
  483.     if (marks == 0)
  484.     marks= new MarkList;
  485.     return marks->MakeIterator();
  486. }
  487.  
  488. MarkList *Text::GetMarkList()
  489. {
  490.     if (marks == 0)
  491.     marks= new MarkList;
  492.     return marks;
  493. }
  494.  
  495. void Text::InspectorId(char *b, int s)
  496. {
  497.     int c;
  498.     AutoTextIter next(this, 0, s-1);
  499.     for (int i= 0; (c= next()) != cEOT; i++)
  500.     b[i]= c;
  501.     b[i]= '\0';
  502. }
  503.  
  504. //---- observing ----------------------------------------------------------
  505.     
  506. Collection *Text::MakeObserverColl()
  507. {
  508.     observers= new OrdCollection(4);
  509.     return observers;
  510. }
  511.  
  512. Collection *Text::GetObservers()
  513. {    
  514.     return observers;
  515. }
  516.  
  517. void Text::DestroyObserverColl()
  518. {
  519.     SafeDelete(observers);
  520. }
  521.  
  522. void Text::SetObserverColl(Collection *cp)
  523. {
  524.     SafeDelete(observers);
  525.     observers= cp;
  526. }
  527.  
  528. //----- class TextIter ----------------------------------------------------
  529.  
  530. TextIter::TextIter(Text *s,int from,int to)
  531. { 
  532.     ct= s; 
  533.     ce= max(from,0); 
  534.     upto= min(to,s->Size());
  535. }
  536.  
  537. void TextIter::Reset(Text *s,int from,int to)
  538. { 
  539.     ct= s; 
  540.     ce= max(from,0); 
  541.     upto= min(to,s->Size());
  542. }
  543.  
  544. int TextIter::operator()(int *,LineDesc*)  
  545. {
  546.     return cEOT;
  547. }
  548.  
  549. int TextIter::operator()()  
  550. {
  551.     return cEOT;
  552. }
  553.  
  554. int TextIter::Line(LineDesc*)  
  555. {
  556.     return cEOT;
  557. }
  558.  
  559. int TextIter::GetPos()  
  560. {
  561.     return ce;
  562. }
  563.  
  564. Font *TextIter::FontAt(int)
  565. { 
  566.     return ct->GetFont(); 
  567. } 
  568.  
  569. int TextIter::Unget()
  570. {
  571.     return ce= unget;
  572. }
  573.  
  574. int TextIter::Token(int *,LineDesc*)  
  575. {
  576.     return cEOT;
  577. }
  578.  
  579. int TextIter::GetLastPos()                 // get last position
  580. { 
  581.     return unget; 
  582. }
  583.  
  584. void TextIter::SetPos(int newPos)
  585. { 
  586.     ce = newPos; 
  587. }
  588.  
  589. AutoTextIter::AutoTextIter(Text *t, int from, int to)
  590. { 
  591.     ti= t->MakeIterator(from,to); 
  592. }
  593.